
# Import all the necessary libraries.
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline 

import warnings
warnings.filterwarnings('ignore')


#Import Dataset
df1 = pd.read_csv('Normal.csv')
df2 = pd.read_csv('Type_H.csv')
df3 = pd.read_csv('Type_S.csv')


# Explore shape and size of first dataset
df1.shape

(100, 7)


# Checking attributes of first dataset
df1.info()
df1.head()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100 entries, 0 to 99
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   P_incidence  100 non-null    float64
 1   P_tilt       100 non-null    float64
 2   L_angle      100 non-null    float64
 3   S_slope      100 non-null    float64
 4   P_radius     100 non-null    float64
 5   S_Degree     100 non-null    float64
 6   Class        100 non-null    object 
dtypes: float64(6), object(1)
memory usage: 5.6+ KB


# Explore shape and size of second dataset
df2.shape

(60, 7)


# Checking attributes of second dataset
df2.info()
df2.head()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 60 entries, 0 to 59
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   P_incidence  60 non-null     float64
 1   P_tilt       60 non-null     float64
 2   L_angle      60 non-null     float64
 3   S_slope      60 non-null     float64
 4   P_radius     60 non-null     float64
 5   S_Degree     60 non-null     float64
 6   Class        60 non-null     object 
dtypes: float64(6), object(1)
memory usage: 3.4+ KB


# Explore shape and size of third dataset
df3.shape

(150, 7)


# Checking attributes of third dataset
df3.info()
df3.head()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   P_incidence  150 non-null    float64
 1   P_tilt       150 non-null    float64
 2   L_angle      150 non-null    float64
 3   S_slope      150 non-null    float64
 4   P_radius     150 non-null    float64
 5   S_Degree     150 non-null    float64
 6   Class        150 non-null    object 
dtypes: float64(6), object(1)
memory usage: 8.3+ KB


# Merging all the 3 datasets over rows
Biomechanics = pd.concat([df1,df2,df3],axis=0,ignore_index=True,sort=False)


# Check the dimensions of final dataset
print(f" Shape of the dataframe = {Biomechanics.shape}")

 Shape of the dataframe = (310, 7)


# Explore data type of each columns of final dataset. 
Biomechanics.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 310 entries, 0 to 309
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   P_incidence  310 non-null    float64
 1   P_tilt       310 non-null    float64
 2   L_angle      310 non-null    float64
 3   S_slope      310 non-null    float64
 4   P_radius     310 non-null    float64
 5   S_Degree     310 non-null    float64
 6   Class        310 non-null    object 
dtypes: float64(6), object(1)
memory usage: 17.1+ KB


# Check attributes of the independent variables AND Checking basic details of the data
Biomechanics.sample(5)


# Let's check the five point summary of each feature in the dataset.
Biomechanics.describe().transpose()


# Check distribution of target variable, 'Class' 
Biomechanics['Class'].value_counts()

Type_S    133
Normal     73
Type_H     37
Nrmal      27
type_h     23
tp_s       17
Name: Class, dtype: int64


# Correcting the values in target variable using replace function.
Biomechanics.Class.replace(['Nrmal','type_h','tp_s'],['Normal','Type_H','Type_S'],inplace=True)


Biomechanics['Class'].value_counts() # There are 3 classes in the target variable.

Type_S    150
Normal    100
Type_H     60
Name: Class, dtype: int64


Biomechanics.isnull().sum()

P_incidence    0
P_tilt         0
L_angle        0
S_slope        0
P_radius       0
S_Degree       0
Class          0
dtype: int64


# Check uniques values i.e. classes in target variable.
Biomechanics.iloc[:,6].unique()

array(['Normal', 'Type_H', 'Type_S'], dtype=object)


# Use label encoder to convert categorical variables to one-hot encoding 

from sklearn.preprocessing import LabelEncoder
class_label_encoder = LabelEncoder()

Biomechanics.iloc[:,-1] = class_label_encoder.fit_transform(Biomechanics.iloc[:,-1])


Biomechanics.sample(5) # Check the encoded labels of target variable, 'Class'


fig = plt.figure(figsize = (15,6))

ra1 = fig.add_subplot(1,3,1) 
ra2 = fig.add_subplot(1,3,2)
ra3 = fig.add_subplot(1,3,3)

ra1.hist(Biomechanics['P_tilt'],color = 'purple')
ra1.set_title('The Distribution of P_tilt')

ra2.hist(Biomechanics['P_radius'],color = 'blue')
ra2.set_title('The Distribution of P_radius')

ra3.hist(Biomechanics['S_Degree'],color = 'orange')
ra3.set_title('The Distribution of S_Degree')


plt.figure(figsize=(20,6))
plt.subplot(1, 3, 1)
plt.title('The Distribution of P_tilt')
sns.boxplot(Biomechanics['P_tilt'],color='purple')

# subplot 2
plt.subplot(1, 3, 2)
plt.title('The Distribution of P_radius')
sns.boxplot(Biomechanics['P_radius'],orient='vertical',color= 'blue')

# subplot 3
plt.subplot(1, 3, 3)
plt.title('The Distribution of S_Degree')
sns.boxplot(Biomechanics['S_Degree'],color='orange')

plt.tight_layout() 
plt.show()


# Observe the relation between all the independent variables and target variable
plt.figure(figsize=(20,15))

plt.subplot(3, 2, 1)
plt.title('The relatio of P_incidence with "Class"')
sns.boxplot(x='Class', y='P_incidence', data= Biomechanics)

plt.subplot(3, 2, 2)
plt.title('The relatio of P_tilt with "Class"')
sns.boxplot(x='Class', y='P_tilt', data= Biomechanics)

plt.subplot(3, 2, 3)
plt.title('The relatio of L_angle with "Class"')
sns.boxplot(x='Class', y='L_angle', data= Biomechanics)

plt.subplot(3, 2, 4)
plt.title('The relatio of S_slope with "Class"')
sns.boxplot(x='Class', y='S_slope', data= Biomechanics)

plt.subplot(3, 2, 5)
plt.title('The relatio of P_radius with "Class"')
sns.boxplot(x='Class', y='P_radius', data= Biomechanics)

plt.subplot(3, 2, 6)
plt.title('The relatio of S_Degree with "Class"')
sns.boxplot(x='Class', y='S_Degree', data= Biomechanics)

plt.show()


#Observe the association of each independent variable with target variable 
# and drop variables from feature set having correlation in range -0.1 to 0.1 with target variable.

corr = Biomechanics.corr()
corr


# Plot the correlation between each feature using seaborn heatmap function.
colormap = plt.cm.plasma
#colormap = plt.cm.viridis
plt.figure(figsize=(12,12))
sns.heatmap(corr,square=True, cmap=colormap, linecolor='white',linewidths=0.2, annot=True)

<AxesSubplot:>


# Compute variance of each variable.
Biomechanics.var()

P_incidence     297.097633
P_tilt          100.166675
L_angle         344.253290
S_slope         180.179672
P_radius        177.352531
S_Degree       1410.680476
Class             0.782963
dtype: float64


# Use pairplot to plot the distribution of each variable.
colormap= sns.color_palette("hls", 3)
sns.pairplot(Biomechanics, hue = 'Class',palette=colormap, diag_kind = 'kde')

<seaborn.axisgrid.PairGrid at 0x24d49ac9af0>


fig,axes =plt.subplots(3,2, figsize=(12, 9)) # Define the image area and subplots for plotting histograms

Normal = Biomechanics[Biomechanics.Class == 1] # Seperate the data of each class   
Type_H = Biomechanics[Biomechanics.Class == 0]
Type_S = Biomechanics[Biomechanics.Class == 2]

ax=axes.ravel()

for i in range(6):
  _,bins=np.histogram(Biomechanics.iloc[:,i],bins=20)
  ax[i].hist(Normal.iloc[:,i],bins=bins,color='r',alpha=.5) 
  ax[i].hist(Type_H.iloc[:,i],bins=bins,color='g',alpha=.4) 
  ax[i].hist(Type_S.iloc[:,i],bins=bins,color='b',alpha=.3) 
  ax[i].set_title(Biomechanics.columns[i],fontsize=9)
  ax[i].axes.get_xaxis().set_visible(False) # the x-axis co-ordinates are not so useful, as we just want to look how well separated the histograms are
  ax[i].set_yticks(())

ax[0].legend(['Normal','Type_H','Type_S'],loc='best',fontsize=8)
plt.tight_layout()# let's make good plots
plt.show()


Biomechanics.Class.value_counts(normalize=True)

2    0.483871
0    0.322581
1    0.193548
Name: Class, dtype: float64


fig,axes=plt.subplots(1,2,figsize=(17,7))
Biomechanics['Class'].value_counts().plot.pie(autopct='%1.1f%%',ax=axes[0])
Biomechanics.Class.value_counts().plot(color = ['red', 'green','blue'],kind='bar',ax=axes[1])
axes[0].set_title('Pie Chart -Target Variable ')
axes[1].set_title('Bar Graph - Target Variable ')
plt.show()


Biomechanics.groupby(["Class"]).count()


# Get outliers from each independent variable and compute the mean of independent variable

columns=['P_incidence','P_tilt','L_angle','S_slope','P_radius','S_Degree']
for i in columns:
    #getting upper and lower quartile values
    Quartile25,Quartile75 = np.percentile(Biomechanics[i],25),np.percentile(Biomechanics[i],75)

    IQR = Quartile75 - Quartile25

    Threshold = IQR * 1.5

    lower = Quartile25 - Threshold
    upper= Quartile75 + Threshold

    Outliers=[j for j in Biomechanics[i] if j < lower or j > upper]

    #taking mean of a column without considering outliers

    df_mean = Biomechanics.loc[(Biomechanics[i] >= lower) & (Biomechanics[i] <= upper)]
    mean = int(df_mean[i].mean())
    print('Mean of {} is {}'.format(i,mean))
    #print('\n')

    #imputing outliers with mean

    Biomechanics[i]=np.where(Biomechanics[i]>upper,mean,Biomechanics[i])
    Biomechanics[i]=np.where(Biomechanics[i]<lower,mean,Biomechanics[i])
    Outliers=[j for j in Biomechanics[i] if j < lower or j > upper]
    print('Total Number of outliers in {} After Imputing : {}'.format(i,len(Outliers)))

Mean of P_incidence is 59
Total Number of outliers in P_incidence After Imputing : 0
Mean of P_tilt is 16
Total Number of outliers in P_tilt After Imputing : 0
Mean of L_angle is 51
Total Number of outliers in L_angle After Imputing : 0
Mean of S_slope is 42
Total Number of outliers in S_slope After Imputing : 0
Mean of P_radius is 118
Total Number of outliers in P_radius After Imputing : 0
Mean of S_Degree is 22
Total Number of outliers in S_Degree After Imputing : 0


# Biomechanics = Biomechanics.drop(labels= "P_radius",axis = 1) # Drop the variable "P_radius" as it has less correlation with the target variable.


# Create a separate dataframe consisting only of the features i.e independent attributes 
# and a dataframe of target variable

X = Biomechanics.drop(labels= "Class" , axis = 1) # Feature set
y = Biomechanics["Class"] # Target variable
X.head()


#standardization of data

from sklearn import preprocessing
from sklearn.preprocessing import StandardScaler

X_std = pd.DataFrame(StandardScaler().fit_transform(X))
X_std.columns = X.columns


X_std.head() # Scaled Features


#split the dataset into training and test datasets

from sklearn.model_selection import train_test_split

# split into train and test
X_train, X_test, y_train, y_test = train_test_split(X_std, y, test_size=0.3,random_state=10)


print(X_train.shape)
print(y_train.shape)

(217, 6)
(217,)


print(X_test.shape)
print(y_test.shape)

(93, 6)
(93,)


from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score,classification_report
from sklearn.metrics import recall_score

Train_score =[]
Test_score =[]

for k in range(1,50):
    NNH = KNeighborsClassifier(n_neighbors = k, metric = 'euclidean', weights = 'distance' )
    NNH.fit(X_train, y_train)
    Train_score.append(NNH.score(X_train, y_train))
    Test_score.append(NNH.score(X_test, y_test))


plt.plot(range(1,50),Train_score)
plt.show()


plt.plot(range(1,50),Test_score)
plt.show()


# loading library
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score,classification_report
from sklearn.metrics import recall_score

# instantiate learning model (k = 3)
knn = KNeighborsClassifier(n_neighbors = 3, weights = 'distance')

# fitting the model
knn.fit(X_train, y_train)

# predict the response
y_pred = knn.predict(X_test)

# evaluate accuracy and generate classification report
print('The accuracy score and Classification Report with K = 3 \n')
print('The model accuracy on test data is :' ,accuracy_score(y_test, y_pred),'\n')
print(classification_report(y_test, y_pred))

# instantiate learning model (k = 5)
knn = KNeighborsClassifier(n_neighbors=5, weights = 'distance')
# fitting the model
knn.fit(X_train, y_train)

# predict the response
y_pred = knn.predict(X_test)

# evaluate accuracy and generate classification report
print('The accuracy score and Classification Report with K = 5 \n')
print('The model accuracy on test data is :' ,accuracy_score(y_test, y_pred),'\n')
print(classification_report(y_test, y_pred))

# instantiate learning model (k = 7)
knn = KNeighborsClassifier(n_neighbors=7, weights = 'distance')

# fitting the model
knn.fit(X_train, y_train)

# predict the response
y_pred = knn.predict(X_test)

# evaluate accuracy and generate classification report
print('The accuracy score and Classification Report with K = 7 \n')
print('The model accuracy on test data is :' ,accuracy_score(y_test, y_pred),'\n')
print(classification_report(y_test, y_pred))

The accuracy score and Classification Report with K = 3 

The model accuracy on test data is : 0.7741935483870968 

              precision    recall  f1-score   support

           0       0.68      0.54      0.60        28
           1       0.50      0.72      0.59        18
           2       0.98      0.94      0.96        47

    accuracy                           0.77        93
   macro avg       0.72      0.73      0.72        93
weighted avg       0.80      0.77      0.78        93

The accuracy score and Classification Report with K = 5 

The model accuracy on test data is : 0.8387096774193549 

              precision    recall  f1-score   support

           0       0.79      0.68      0.73        28
           1       0.62      0.83      0.71        18
           2       0.98      0.94      0.96        47

    accuracy                           0.84        93
   macro avg       0.80      0.82      0.80        93
weighted avg       0.85      0.84      0.84        93

The accuracy score and Classification Report with K = 7 

The model accuracy on test data is : 0.8279569892473119 

              precision    recall  f1-score   support

           0       0.74      0.71      0.73        28
           1       0.64      0.78      0.70        18
           2       0.98      0.91      0.95        47

    accuracy                           0.83        93
   macro avg       0.78      0.80      0.79        93
weighted avg       0.84      0.83      0.83        93


from sklearn import metrics

cm =metrics.confusion_matrix(y_test,y_pred)
print('The Confusion Matrix :\n',cm)

colormap = plt.cm.inferno
plt.figure(figsize=(10,10))
sns.heatmap(cm, xticklabels=['NORMAL_ACTUAL', 'TYPE_H__ACTUAL','TYPE_S__ACTUAL'],yticklabels= ['NORMAL_PREDICT', 'TYPE_H_PREDICT','TYPE_S_PREDICT'],square=True, cmap=colormap, linecolor='white', linewidths= 0.2, annot=True)

The Confusion Matrix :
 [[20  7  1]
 [ 4 14  0]
 [ 3  1 43]]

<AxesSubplot:>


# creating list of K as odd values for KNN
myList = list(range(1,20))

# subsetting just the odd ones
neighbors = list(filter(lambda x: x % 2 != 0, myList))


# empty list that will hold accuracy scores
ac_scores = []
Recall_scores =[]

# perform accuracy metrics for values from 1,3,5....19
for k in neighbors:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    # predict the response
    y_pred = knn.predict(X_test)
    # evaluate accuracy
    scores = accuracy_score(y_test, y_pred)
    ac_scores.append(scores)
    # Evaluate Recall Score
    scores_r = recall_score(y_test, y_pred,average='macro')
    Recall_scores.append(scores_r)

# changing to misclassification error
MSE = [1 - x for x in ac_scores]
MSE_R = [1 - x for x in Recall_scores]

# determining best k based on accuracy score
optimal_k = neighbors[MSE.index(min(MSE))]
print("Based on accuracy score, The optimal number of neighbors is %d" % optimal_k)

# determining best k based on Recall score
optimal_k_R = neighbors[MSE_R.index(min(MSE_R))]
print("Based on Recall score, The optimal number of neighbors is %d" % optimal_k_R)

Based on accuracy score, The optimal number of neighbors is 5
Based on Recall score, The optimal number of neighbors is 5


import matplotlib.pyplot as plt
# plot misclassification error vs k
plt.plot(neighbors, MSE)
plt.xlabel('Number of Neighbors K')
plt.ylabel('Misclassification Error')
plt.show()


# Use k=5 as the final model for prediction

knn = KNeighborsClassifier(n_neighbors = 5,weights='distance')

# fitting the model
knn.fit(X_train, y_train)

# predict the response
y_pred = knn.predict(X_test)

# evaluate accuracy and Recall scores
print('The Training Score :{:.2f}'.format(knn.score(X_train,y_train)*100))
print('The Test Score :{:.2f}'.format(knn.score(X_test,y_test)*100),'\n')

print('The accuracy score of final trained model on test data is: {:.2f}'.format(accuracy_score(y_test, y_pred)))
print('The Recall score of final trained model on test data is : {:.2f}'.format(recall_score(y_test, y_pred,average='macro')))

The Training Score :100.00
The Test Score :83.87 

The accuracy score of final trained model on test data is: 0.84
The Recall score of final trained model on test data is : 0.82


#computing Confusion Matrix
from sklearn import metrics


cm =metrics.confusion_matrix(y_test,y_pred)
print('The Confusion Matrix :\n',cm)

colormap = plt.cm.YlGnBu
plt.figure(figsize=(10,10))
sns.heatmap(cm, xticklabels=['NORMAL_ACTUAL', 'TYPE_H__ACTUAL','TYPE_S__ACTUAL'],yticklabels= ['NORMAL_PREDICT', 'TYPE_H_PREDICT','TYPE_S_PREDICT'],square=True, cmap=colormap, linecolor='black', linewidths =0.5,annot=True)
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Predicted label')
plt.xlabel('Actual label')

The Confusion Matrix :
 [[19  8  1]
 [ 3 15  0]
 [ 2  1 44]]

Text(0.5, 155.72222222222217, 'Actual label')


# Classification Report

print(classification_report(y_test,y_pred))

              precision    recall  f1-score   support

           0       0.79      0.68      0.73        28
           1       0.62      0.83      0.71        18
           2       0.98      0.94      0.96        47

    accuracy                           0.84        93
   macro avg       0.80      0.82      0.80        93
weighted avg       0.85      0.84      0.84        93


from sklearn.metrics import roc_curve
from sklearn.metrics import auc
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import label_binarize
from sklearn.multiclass import OneVsRestClassifier
from itertools import cycle

y = label_binarize(y, classes=[0, 1, 2])
n_classes = y.shape[1]

X_train, X_test, y_train, y_test = train_test_split(X_std, y, test_size=0.3,random_state=10)

knn_cv = KNeighborsClassifier(n_neighbors=5)

y_score = knn.predict_proba(X_test)

fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
    fpr[i], tpr[i], _ = roc_curve(y_test[:,i], y_score[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])

# Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])

lw =2
colors = cycle(['deeppink', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(n_classes), colors):
    plt.plot(fpr[i], tpr[i], color=color, lw=lw,
             label='ROC curve of class {0} (area = {1:0.2f})'
             ''.format(i, roc_auc[i]))

plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()


data1 = pd.read_csv('Data1.csv')
data2 = pd.read_csv('Data2.csv')


data1.shape

(5000, 8)


data1.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5000 entries, 0 to 4999
Data columns (total 8 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   ID                   5000 non-null   int64  
 1   Age                  5000 non-null   int64  
 2   CustomerSince        5000 non-null   int64  
 3   HighestSpend         5000 non-null   int64  
 4   ZipCode              5000 non-null   int64  
 5   HiddenScore          5000 non-null   int64  
 6   MonthlyAverageSpend  5000 non-null   float64
 7   Level                5000 non-null   int64  
dtypes: float64(1), int64(7)
memory usage: 312.6 KB


data1.sample(5)


data2.shape

(5000, 7)


data2.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5000 entries, 0 to 4999
Data columns (total 7 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   ID                   5000 non-null   int64  
 1   Mortgage             5000 non-null   int64  
 2   Security             5000 non-null   int64  
 3   FixedDepositAccount  5000 non-null   int64  
 4   InternetBanking      5000 non-null   int64  
 5   CreditCard           5000 non-null   int64  
 6   LoanOnCard           4980 non-null   float64
dtypes: float64(1), int64(6)
memory usage: 273.6 KB


data2.sample(5)


data2.isnull().sum()

ID                      0
Mortgage                0
Security                0
FixedDepositAccount     0
InternetBanking         0
CreditCard              0
LoanOnCard             20
dtype: int64


data2['LoanOnCard'] = data2['LoanOnCard'].fillna(0)


data2.isnull().sum()

ID                     0
Mortgage               0
Security               0
FixedDepositAccount    0
InternetBanking        0
CreditCard             0
LoanOnCard             0
dtype: int64


BankRecords = data1.merge(data2, on='ID')


BankRecords.head()


BankRecords.shape

(5000, 14)


BankRecords.describe()


BankRecords.isnull().sum()

ID                     0
Age                    0
CustomerSince          0
HighestSpend           0
ZipCode                0
HiddenScore            0
MonthlyAverageSpend    0
Level                  0
Mortgage               0
Security               0
FixedDepositAccount    0
InternetBanking        0
CreditCard             0
LoanOnCard             0
dtype: int64


BankRecords.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5000 entries, 0 to 4999
Data columns (total 14 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   ID                   5000 non-null   int64  
 1   Age                  5000 non-null   int64  
 2   CustomerSince        5000 non-null   int64  
 3   HighestSpend         5000 non-null   int64  
 4   ZipCode              5000 non-null   int64  
 5   HiddenScore          5000 non-null   int64  
 6   MonthlyAverageSpend  5000 non-null   float64
 7   Level                5000 non-null   int64  
 8   Mortgage             5000 non-null   int64  
 9   Security             5000 non-null   int64  
 10  FixedDepositAccount  5000 non-null   int64  
 11  InternetBanking      5000 non-null   int64  
 12  CreditCard           5000 non-null   int64  
 13  LoanOnCard           5000 non-null   float64
dtypes: float64(2), int64(12)
memory usage: 585.9 KB


# Changing datatypes of categorical features

cols=['HiddenScore','Level','Security','FixedDepositAccount', 'InternetBanking', 'CreditCard', 'LoanOnCard']
for i in cols:
    BankRecords[i]=BankRecords[i].astype('category')


BankRecords = BankRecords.drop(labels= "ID" , axis = 1)


fig = plt.figure(figsize = (15,6))

ra1 = fig.add_subplot(1,3,1) 
ra2 = fig.add_subplot(1,3,2)
ra3 = fig.add_subplot(1,3,3)

ra1.hist(BankRecords['Age'],color = 'red')
ra1.set_title('The Distribution of Age')

ra2.hist(BankRecords['HighestSpend'],color = 'skyblue')
ra2.set_title('The Distribution of Highest Spend')

ra3.hist(BankRecords['MonthlyAverageSpend'],color = 'green')
ra3.set_title('The Distribution of Monthly Average Spend')


plt.figure(figsize=(20,6))
plt.subplot(1, 3, 1)
plt.title('The Distribution of Age')
sns.boxplot(BankRecords['Age'],color='red')

# subplot 2
plt.subplot(1, 3, 2)
plt.title('The Distribution of Highest Spend')
sns.boxplot(BankRecords['HighestSpend'],orient='vertical',color= 'skyblue')

# subplot 3
plt.subplot(1, 3, 3)
plt.title('The Distribution of Monthly Average Spend')
sns.boxplot(BankRecords['MonthlyAverageSpend'],color='green')

plt.tight_layout() 
plt.show()


fig = plt.figure(figsize = (15,6))

ra1 = fig.add_subplot(1,3,1) 
ra2 = fig.add_subplot(1,3,2)
ra3 = fig.add_subplot(1,3,3)

ra1.hist(BankRecords['CustomerSince'],color = 'pink')
ra1.set_title('The Distribution of CustomerSince')

ra2.hist(BankRecords['ZipCode'],color = 'yellow')
ra2.set_title('The Distribution of ZipCode')

ra3.hist(BankRecords['Mortgage'],color = 'green')
ra3.set_title('The Distribution of Mortgage')


plt.figure(figsize=(12,6))
plt.subplot(1, 3, 1)
plt.title('The Distribution of CustomerSince ')
sns.boxplot(BankRecords['CustomerSince'],color='pink')

# subplot 2
plt.subplot(1, 3, 2)
plt.title('The Distribution of ZipCode')
sns.boxplot(BankRecords['ZipCode'],orient='vertical',color= 'yellow')

# subplot 3
plt.subplot(1, 3, 3)
plt.title('The Distribution of Mortgage')
sns.boxplot(BankRecords['Mortgage'],color='green')

plt.tight_layout() 
plt.show()


print('The mean period of cutomers as a client of the bank is: ', BankRecords['CustomerSince'].mean())

#sns.boxplot(BankRecords['CustomerSince'],orient='vertical')
dist_cust_since = BankRecords['CustomerSince'].plot(kind = 'box', figsize = (6,6),title='The Distribution of Duration of Customer')
plt.show()

The mean period of cutomers as a client of the bank is:  20.1046


cols=['HiddenScore','Level','Security','FixedDepositAccount', 'InternetBanking', 'CreditCard', 'LoanOnCard']

fig = plt.figure(figsize = (15,15))

plt.subplot(3, 2, 1)
plt.title('Pie plot - HiddenScore ')
BankRecords['HiddenScore'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 2)
plt.title('Bar graph - HiddenScore ')
BankRecords.HiddenScore.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')

plt.subplot(3, 2, 3)
plt.title('Pie plot - Level ')
BankRecords['Level'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 4)
plt.title('Bar graph -Level ')
BankRecords.Level.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')


plt.subplot(3, 2, 5)
plt.title('Pie plot - Security ')
BankRecords['Security'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 6)
plt.title('Bar graph -Security')
BankRecords.Security.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')

plt.tight_layout() 
plt.show()


cols=['HiddenScore','Level','Security','FixedDepositAccount', 'InternetBanking', 'CreditCard', 'LoanOnCard']

fig = plt.figure(figsize = (15,15))

plt.subplot(3, 2, 1)
plt.title('Pie plot - InternetBanking ')
BankRecords['InternetBanking'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 2)
plt.title('Bar graph - InternetBanking')
BankRecords.InternetBanking.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')

plt.subplot(3, 2, 3)
plt.title('Pie plot - CreditCard')
BankRecords['CreditCard'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 4)
plt.title('Bar graph -CreditCard')
BankRecords.CreditCard.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')

plt.subplot(3, 2, 5)
plt.title('Pie plot - FixedDepositAccount')
BankRecords['FixedDepositAccount'].value_counts().plot.pie(autopct='%1.1f%%')

plt.subplot(3, 2, 6)
plt.title('Bar graph -FixedDepositAccount')
BankRecords.FixedDepositAccount.value_counts().plot(color = ['blue','orange', 'green','red'],kind='bar')

plt.tight_layout() 
plt.show()


plt.figure(figsize=(12,6))
plt.subplot(2, 1, 1)
plt.title('The Relationship between LoanOnCard and HighestSpend ')
sns.boxplot(x='HighestSpend',y='LoanOnCard',data=BankRecords,color='purple')


plt.subplot(2, 1, 2)
plt.title('The Relationship between LoanOnCard and MonthlyAverageSpend ')
sns.boxplot(x='MonthlyAverageSpend',y='LoanOnCard',data=BankRecords,color='green')

plt.tight_layout()
plt.show()


fig = plt.figure(figsize = (10,6))

sns.countplot(x ='CustomerSince', data = BankRecords,hue='LoanOnCard')

plt.show()


cols=['HiddenScore','Level','Security','FixedDepositAccount', 'InternetBanking', 'CreditCard', 'LoanOnCard']

plt.figure(figsize=(12,12))

plt.subplot(3, 2, 1)
plt.title('Bar plot - HiddenScore vs LoanOnCard ')
sns.countplot(BankRecords['HiddenScore'],hue=BankRecords['LoanOnCard'])

plt.subplot(3, 2, 2)
plt.title('Bar plot - Level vs LoanOnCard ')
sns.countplot(BankRecords['Level'],hue=BankRecords['LoanOnCard'])

plt.subplot(3, 2, 3)
plt.title('Bar plot - Security vs LoanOnCard ')
sns.countplot(BankRecords['Security'],hue=BankRecords['LoanOnCard'])

plt.subplot(3, 2, 4)
plt.title('Bar plot - InternetBanking vs LoanOnCard ')
sns.countplot(BankRecords['InternetBanking'],hue=BankRecords['LoanOnCard'])

plt.subplot(3, 2, 5)
plt.title('Bar plot - CreditCard vs LoanOnCard ')
sns.countplot(BankRecords['CreditCard'],hue=BankRecords['LoanOnCard'])

plt.subplot(3, 2, 6)
plt.title('Bar plot - CreditCard vs LoanOnCard ')
sns.countplot(BankRecords['FixedDepositAccount'],hue=BankRecords['LoanOnCard'])

plt.tight_layout() 
plt.show()


from pandas.plotting import scatter_matrix
matrix = scatter_matrix(BankRecords[['Age','CustomerSince','HighestSpend','MonthlyAverageSpend','Mortgage','LoanOnCard']],figsize=(10,8))

plt.suptitle('The Scatter Matrix of Age, CustomerSince, HighestSpend, MonthlyAverageSpend, Mortgage,LoanOnCard')
plt.show()


colormap= sns.color_palette("hls", 2)

sns.pairplot(BankRecords, diag_kind = "kde",palette=colormap, hue = "LoanOnCard")

<seaborn.axisgrid.PairGrid at 0x24d49c0aa90>


corr = BankRecords.corr()


# Plot the correlation between each feature using seaborn heatmap function.
colormap = plt.cm.YlOrRd
#colormap = plt.cm.viridis
plt.figure(figsize=(12,12))
sns.heatmap(corr,square=True, cmap=colormap, linecolor='black',linewidths=0.2, annot=True)

<AxesSubplot:>


BankRecords.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5000 entries, 0 to 4999
Data columns (total 13 columns):
 #   Column               Non-Null Count  Dtype   
---  ------               --------------  -----   
 0   Age                  5000 non-null   int64   
 1   CustomerSince        5000 non-null   int64   
 2   HighestSpend         5000 non-null   int64   
 3   ZipCode              5000 non-null   int64   
 4   HiddenScore          5000 non-null   category
 5   MonthlyAverageSpend  5000 non-null   float64 
 6   Level                5000 non-null   category
 7   Mortgage             5000 non-null   int64   
 8   Security             5000 non-null   category
 9   FixedDepositAccount  5000 non-null   category
 10  InternetBanking      5000 non-null   category
 11  CreditCard           5000 non-null   category
 12  LoanOnCard           5000 non-null   category
dtypes: category(7), float64(1), int64(5)
memory usage: 437.6 KB


BankRecords_Copy = BankRecords.copy(deep=True)


from scipy.stats import ttest_ind,ttest_1samp

Grp1=BankRecords_Copy[BankRecords['LoanOnCard'] == 0]
Grp2=BankRecords_Copy[BankRecords['LoanOnCard'] == 1]

columns = ['Age','CustomerSince','HighestSpend','ZipCode','MonthlyAverageSpend','Mortgage']

for i in columns:
  t_statistic, p_value = ttest_ind(Grp1[i], Grp2[i])
  print('t_statistic and p_value of {} : {} and {}'.format(i,t_statistic, p_value) )

  if p_value < 0.05:  # Setting our significance level at 5%
        print('Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of {}'.format(i))
        print('\n')
  else:
        print('Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of {}'.format(i))
        print('\n')

t_statistic and p_value of Age : 0.5461906615539323 and 0.584959263705325
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of Age


t_statistic and p_value of CustomerSince : 0.5240947451995412 and 0.600235883164189
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of CustomerSince


t_statistic and p_value of HighestSpend : -41.08533291207552 and 0.0
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of HighestSpend


t_statistic and p_value of ZipCode : -0.007591136189874719 and 0.9939435107708496
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of ZipCode


t_statistic and p_value of MonthlyAverageSpend : -27.882127015069404 and 3.8302661578168557e-159
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of MonthlyAverageSpend


t_statistic and p_value of Mortgage : -10.148618914431497 and 5.73034172157401e-24
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of Mortgage


# Dropping non - categorical features that have less correlation with target variable
BankRecords.drop(['Age','CustomerSince','ZipCode'],inplace = True, axis =1)


BankRecords.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5000 entries, 0 to 4999
Data columns (total 10 columns):
 #   Column               Non-Null Count  Dtype   
---  ------               --------------  -----   
 0   HighestSpend         5000 non-null   int64   
 1   HiddenScore          5000 non-null   category
 2   MonthlyAverageSpend  5000 non-null   float64 
 3   Level                5000 non-null   category
 4   Mortgage             5000 non-null   int64   
 5   Security             5000 non-null   category
 6   FixedDepositAccount  5000 non-null   category
 7   InternetBanking      5000 non-null   category
 8   CreditCard           5000 non-null   category
 9   LoanOnCard           5000 non-null   category
dtypes: category(7), float64(1), int64(2)
memory usage: 320.4 KB


import scipy.stats as stats

cols = ['HiddenScore','Level','Security','FixedDepositAccount','InternetBanking','CreditCard']

for i in cols:
  crosstab=pd.crosstab(BankRecords_Copy['LoanOnCard'],BankRecords_Copy[i])
  chi_sq_Stat, p_value, deg_freedom, exp_freq = stats.chi2_contingency(crosstab)

  print('Chi-square statistic: %3.5f , P value:  %1.6f' %(chi_sq_Stat, p_value))

  if p_value < 0.05:  # Setting our significance level at 5%
        print('Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of {}'.format(i))
        print('\n')
  else:
        print('Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of {}'.format(i))
        print('\n')

Chi-square statistic: 29.67612 , P value:  0.000002
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of HiddenScore


Chi-square statistic: 111.23987 , P value:  0.000000
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of Level


Chi-square statistic: 2.17231 , P value:  0.140515
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of Security


Chi-square statistic: 495.90424 , P value:  0.000000
Rejecting Null Hypothesis: Loan holders and non-Loan holders does NOT have same distribution of FixedDepositAccount


Chi-square statistic: 0.15601 , P value:  0.692860
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of InternetBanking


Chi-square statistic: 0.02114 , P value:  0.884386
Fail to Reject Null Hypothesis: Loan holders and non-Loan holders have same distribution of CreditCard


# Dropping categorical features that have less correlation with target variable
BankRecords.drop(['Security','InternetBanking','CreditCard'],inplace = True, axis =1)


BankRecords.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5000 entries, 0 to 4999
Data columns (total 7 columns):
 #   Column               Non-Null Count  Dtype   
---  ------               --------------  -----   
 0   HighestSpend         5000 non-null   int64   
 1   HiddenScore          5000 non-null   category
 2   MonthlyAverageSpend  5000 non-null   float64 
 3   Level                5000 non-null   category
 4   Mortgage             5000 non-null   int64   
 5   FixedDepositAccount  5000 non-null   category
 6   LoanOnCard           5000 non-null   category
dtypes: category(4), float64(1), int64(2)
memory usage: 305.4 KB


# Calculating outliers for the independent features (non Categorical ) from above analysis.

columns=['Mortgage', 'HighestSpend','MonthlyAverageSpend']
for i in columns:
    #getting upper and lower quartile values
    Quartile25,Quartile75 = np.percentile(BankRecords[i],25),np.percentile(BankRecords[i],75)

    IQR = Quartile75 - Quartile25

    Threshold = IQR * 1.5

    lower = Quartile25 - Threshold
    upper= Quartile75 + Threshold

    Outliers=[j for j in BankRecords[i] if j < lower or j > upper]

    #taking mean of a column without considering outliers

    df1_mean = BankRecords.loc[(BankRecords[i] >= lower) & (BankRecords[i] <= upper)]
    mean = int(df1_mean[i].mean())
    print('Mean of {} is {}'.format(i,mean))
    

    #imputing outliers with mean

    BankRecords[i]=np.where(BankRecords[i]>upper,mean,BankRecords[i])
    BankRecords[i]=np.where(BankRecords[i]<lower,mean,BankRecords[i])
    Outliers=[j for j in BankRecords[i] if j < lower or j > upper]
    print('Total Number of outliers in {} After Imputing : {}'.format(i,len(Outliers)))
    print('\n')

Mean of Mortgage is 38
Total Number of outliers in Mortgage After Imputing : 0


Mean of HighestSpend is 71
Total Number of outliers in HighestSpend After Imputing : 0


Mean of MonthlyAverageSpend is 1
Total Number of outliers in MonthlyAverageSpend After Imputing : 0


#Check the distribution of target variable.

BankRecords.LoanOnCard.value_counts().plot(color = ['red', 'green'],kind='bar')

<AxesSubplot:>


# Getting value counts of target variable
BankRecords.LoanOnCard.value_counts()

0.0    4520
1.0     480
Name: LoanOnCard, dtype: int64


# Seperating features from target variable.

X = BankRecords.drop('LoanOnCard',axis = 1)
y = BankRecords['LoanOnCard']


X.shape

(5000, 6)


y.shape

(5000,)


# import library for balancing the data using oversampling.

from imblearn.over_sampling import SMOTE

smote = SMOTE(ratio='minority')
X_sm, y_sm = smote.fit_sample(X, y) # Fit the data for sampling

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_40140\3030194803.py in <module>
      1 # import library for balancing the data using oversampling.
      2 
----> 3 from imblearn.over_sampling import SMOTE
      4 
      5 smote = SMOTE(ratio='minority')

ModuleNotFoundError: No module named 'imblearn'


X_sm.shape # shape of data after oversampling


y_sm  # shape of data after oversampling


#Check no of data points in each class of target variable.
unique, counts = np.unique(y_sm, return_counts=True)
print(unique,counts)


# Splitting the data into training and testing set.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_sm, y_sm, test_size = 0.3, random_state = 1)


X_train.shape


#Import Libraries

from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.metrics import accuracy_score


from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB


models = []
models.append(('LR', LogisticRegression(solver='liblinear')))
models.append(('NB', GaussianNB()))


results_c = []
names_c = []

for name, model in models:
    # define how to split off validation data ('kfold' how many folds)
    kfold = KFold(n_splits=10, random_state=1)    
    # train the model
    cv_results = cross_val_score(model, X_train, y_train, cv=kfold, scoring='accuracy')    
    results_c.append(cv_results)
    names_c.append(name)
    msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
    print('The Mean and Std. Deviation of the model on k-fold (10) cross validation :',msg)


fig = plt.figure()
fig.suptitle('Perfomance of Classification Algorithms')
ax = fig.add_subplot(111)
plt.boxplot(results_c)
ax.set_xticklabels(names_c)
plt.show()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_40140\2222913953.py in <module>
      2 fig.suptitle('Perfomance of Classification Algorithms')
      3 ax = fig.add_subplot(111)
----> 4 plt.boxplot(results_c)
      5 ax.set_xticklabels(names_c)
      6 plt.show()

NameError: name 'results_c' is not defined


model = LogisticRegression(solver='liblinear')
model.fit(X_train,y_train)

y_predict = model.predict(X_test)

y_prediction_train = model.predict(X_train)

TestScore = model.score(X_test,y_test)

TrainScore = model.score(X_train,y_train)
print('The accuracy of Logistic Regression on Test data:',TestScore)
print('\n')
print('The accuracy of Logistic Regression on Train Data :',TrainScore)


#computing Confusion Matrix
from sklearn import metrics

cm = metrics.confusion_matrix(y_test,y_predict)
print('The Confusion Matrix :\n',cm)

colormap = plt.cm.magma
plt.figure(figsize=(7,7))
sns.heatmap(cm, xticklabels=['No Loan taken_ACTUAL', 'Loan__ACTUAL'],yticklabels= ['No Loan taken', 'Loan_PREDICT'], cmap=colormap, linecolor='black', linewidths =0.5,annot=True, fmt='g')

plt.title('Confusion matrix')
plt.ylabel('Predicted label')
plt.xlabel('Actual label')


# Classification Report on training data
from sklearn.metrics import classification_report

print('The Classification report of training data : \n', classification_report(y_train, y_prediction_train))


# Classification Report on testing data

print('The Classification report of testing data : \n', classification_report(y_test, y_predict))


# Apply scaler() to all the columns
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.fit_transform(X_test)


from sklearn import metrics
from sklearn.naive_bayes import GaussianNB

nb = GaussianNB()

nb.fit(X_train_scaled, y_train)

nb_predict = nb.predict(X_test_scaled)

print('The accuracy of Naive Bayes :', nb.score(X_test_scaled,y_test))


from sklearn import metrics
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(solver='liblinear')
model.fit(X_train_scaled,y_train)

y_predict = model.predict(X_test_scaled)
y_prediction_train = model.predict(X_train_scaled)

TestScore = model.score(X_test_scaled,y_test)
TrainScore = model.score(X_train_scaled,y_train)
print('The accuracy of Logistic Regression on Test data:',TestScore)
print('\n')
print('The accuracy of Logistic Regression on Train Data :',TrainScore)


#computing Confusion Matrix
from sklearn import metrics

cm = metrics.confusion_matrix(y_test,y_predict,labels=[0, 1])
print('The Confusion Matrix :\n',cm)

df_cm = pd.DataFrame(cm, index = [i for i in ["Non-Loan holders","Loan holders"]],
                  columns = [i for i in ["Non-Loan holders","Loan holders"]])
colormap = plt.cm.OrRd
plt.figure(figsize=(7,7))
sns.heatmap(df_cm, xticklabels=['No Loan holders_ACTUAL', 'Loan holders__ACTUAL'],yticklabels= ['No Loan holders_PREDICT', 'Loan holders_PREDICT'],square=True, cmap=colormap, linecolor='black', linewidths =0.5,annot=True,fmt='g')

plt.title('Confusion matrix')
plt.ylabel('Predicted label')
plt.xlabel('Actual label')


# Classification Report of train data
from sklearn.metrics import classification_report

print("The Classification report of training data: \n " ,classification_report(y_train,y_prediction_train))


# Classification Report of test data
from sklearn.metrics import classification_report

print("The Classification report of testing data: \n " ,classification_report(y_test, y_predict))


from statsmodels.stats.outliers_influence import variance_inflation_factor

vif = pd.DataFrame()

X =pd.DataFrame (X_train_scaled,columns=X.columns)
vif['Features'] = X.columns
vif["VIF"] = [variance_inflation_factor(X.values, i)
                          for i in range(len(X.columns))]
vif['VIF'] = round(vif['VIF'], 2)
vif = vif.sort_values(by = "VIF", ascending = False)
vif


# Load the dataset without oversampling 
X = BankRecords.drop('LoanOnCard',axis = 1)
y = BankRecords['LoanOnCard']


# Shape of dataset.
X.shape


y.shape


X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 1)


smote = SMOTE(ratio='minority')
X_train_sm, y_train_sm = smote.fit_sample(X_train, y_train)


X_train_sm.shape


model = LogisticRegression(solver='liblinear')
model.fit(X_train_sm,y_train_sm)

y_predict = model.predict(X_test)
y_prediction_train = model.predict(X_train_sm)

Train_score = model.score(X_train_sm,y_train_sm)
print('The training accuracy of Logistic Regression :',Train_score)
print('\n')
Test_score = model.score(X_test,y_test)
print('The testing accuracy of Logistic Regression :',Test_score)


#computing Confusion Matrix
from sklearn import metrics

cm = metrics.confusion_matrix(y_test,y_predict)
print('The Confusion Matrix :\n',cm)

colormap = plt.cm.binary
plt.figure(figsize=(7,7))
sns.heatmap(cm, xticklabels=['No Loan taken_ACTUAL', 'Loan__ACTUAL'],yticklabels= ['No Loan taken', 'Loan_PREDICT'],square=True, cmap=colormap, linecolor='black', linewidths =0.5,annot=True, fmt='g')

plt.title('Confusion matrix', y=1.1)
plt.ylabel('Predicted label')
plt.xlabel('Actual label')


# Classification Report of train data

print("The Classification report of training data: \n " ,classification_report(y_train_sm,y_prediction_train))


# Classification Report of test data

print("The Classification report of training data: \n " ,classification_report(y_test, y_predict))

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
0	38.505273	16.964297	35.112814	21.540976	127.632875	7.986683	Normal
1	54.920858	18.968430	51.601455	35.952428	125.846646	2.001642	Normal
2	44.362490	8.945435	46.902096	35.417055	129.220682	4.994195	Normal
3	48.318931	17.452121	48.000000	30.866809	128.980308	-0.910941	Normal
4	45.701789	10.659859	42.577846	35.041929	130.178314	-3.388910	Normal

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
0	63.027817	22.552586	39.609117	40.475232	98.672917	-0.254400	Type_H
1	39.056951	10.060991	25.015378	28.995960	114.405425	4.564259	Type_H
2	68.832021	22.218482	50.092194	46.613539	105.985135	-3.530317	Type_H
3	69.297008	24.652878	44.311238	44.644130	101.868495	11.211523	Type_H
4	49.712859	9.652075	28.317406	40.060784	108.168725	7.918501	Type_H

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
0	74.377678	32.053104	78.772013	42.324573	143.560690	56.125906	Type_S
1	89.680567	32.704435	83.130732	56.976132	129.955476	92.027277	Type_S
2	44.529051	9.433234	52.000000	35.095817	134.711772	29.106575	Type_S
3	77.690577	21.380645	64.429442	56.309932	114.818751	26.931841	Type_S
4	76.147212	21.936186	82.961502	54.211027	123.932010	10.431972	Type_S

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
222	80.074914	48.069531	52.403439	32.005383	110.709912	67.727316	Type_S
45	67.538182	14.655042	58.001429	52.883139	123.632260	25.970206	Normal
197	74.720746	19.756942	82.735360	54.963804	109.356594	33.306067	Type_S
227	80.433428	16.998479	66.536018	63.434949	116.438981	57.781250	Type_S
34	63.026300	27.336240	51.605017	35.690060	114.506608	7.439870	Nrmal

	count	mean	std	min	25%	50%	75%	max
P_incidence	310.0	60.496653	17.236520	26.147921	46.430294	58.691038	72.877696	129.834041
P_tilt	310.0	17.542822	10.008330	-6.554948	10.667069	16.357689	22.120395	49.431864
L_angle	310.0	51.930930	18.554064	14.000000	37.000000	49.562398	63.000000	125.742385
S_slope	310.0	42.953831	13.423102	13.366931	33.347122	42.404912	52.695888	121.429566
P_radius	310.0	117.920655	13.317377	70.082575	110.709196	118.268178	125.467674	163.071041
S_Degree	310.0	26.296694	37.559027	-11.058179	1.603727	11.767934	41.287352	418.543082

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
202	70.399308	13.469986	61.200000	56.929322	102.337524	25.538429	2
226	70.676898	21.704402	59.181161	48.972496	103.008354	27.810148	2
255	66.804796	14.551602	72.084912	52.253195	82.456038	41.685474	2
52	42.517272	14.375671	25.323565	28.141601	128.905689	0.757020	0
127	43.580964	16.508884	47.000000	27.072080	109.271634	8.992816	1

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree	Class
P_incidence	1.000000	0.629199	0.717282	0.814960	-0.247467	0.638743	0.537638
P_tilt	0.629199	1.000000	0.432764	0.062345	0.032668	0.397862	0.348231
L_angle	0.717282	0.432764	1.000000	0.598387	-0.080344	0.533667	0.525466
S_slope	0.814960	0.062345	0.598387	1.000000	-0.342128	0.523557	0.430734
P_radius	-0.247467	0.032668	-0.080344	-0.342128	1.000000	-0.026065	-0.304099
S_Degree	0.638743	0.397862	0.533667	0.523557	-0.026065	1.000000	0.608705
Class	0.537638	0.348231	0.525466	0.430734	-0.304099	0.608705	1.000000

	P_incidence	P_tilt	L_angle	S_slope	P_radius	S_Degree
0	-1.327329	0.049553	-0.918802	-1.674307	0.845262	-0.563982
1	-0.308608	0.288410	-0.004898	-0.533804	0.687522	-0.801576
2	-0.963841	-0.906150	-0.265366	-0.576173	0.985479	-0.682778
3	-0.718311	0.107693	-0.204513	-0.936273	0.964252	-0.917200
4	-0.880726	-0.701822	-0.505043	-0.605860	1.070047	-1.015570

	ID	Age	CustomerSince	HighestSpend	ZipCode	HiddenScore	MonthlyAverageSpend	Level
4139	4140	29	3	81	95827	1	2.9	3
2106	2107	62	38	132	90210	1	2.9	1
521	522	48	24	75	92518	4	1.4	2
4362	4363	28	2	55	93940	3	1.1	2
2416	2417	60	35	32	93611	1	0.3	3

	ID	Mortgage	Security	InternetBanking	CreditCard	LoanOnCard
1004	1005	0	0	1	0	0.0
3030	3031	0	0	1	0	0.0
3894	3895	81	0	1	1	0.0
2268	2269	0	1	0	0	1.0
4020	4021	194	0	0	1	1.0

	ID	Age	CustomerSince	HighestSpend	ZipCode	HiddenScore	MonthlyAverageSpend	Level	Security	CreditCard
0	1	25	1	49	91107	4	1.6	1	1	0
1	2	45	19	34	90089	3	1.5	1	1	0
2	3	39	15	11	94720	1	1.0	1	0	0
3	4	35	9	100	94112	1	2.7	2	0	0
4	5	35	8	45	91330	4	1.0	2	0	1

	ID	Age	CustomerSince	HighestSpend	ZipCode	HiddenScore	MonthlyAverageSpend	Level	Mortgage	Security	FixedDepositAccount	InternetBanking	CreditCard	LoanOnCard
count	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.000000	5000.00000	5000.000000	5000.000000	5000.000000
mean	2500.500000	45.338400	20.104600	73.774200	93152.503000	2.396400	1.937938	1.881000	56.498800	0.104400	0.06040	0.596800	0.294000	0.096000
std	1443.520003	11.463166	11.467954	46.033729	2121.852197	1.147663	1.747659	0.839869	101.713802	0.305809	0.23825	0.490589	0.455637	0.294621
min	1.000000	23.000000	-3.000000	8.000000	9307.000000	1.000000	0.000000	1.000000	0.000000	0.000000	0.00000	0.000000	0.000000	0.000000
25%	1250.750000	35.000000	10.000000	39.000000	91911.000000	1.000000	0.700000	1.000000	0.000000	0.000000	0.00000	0.000000	0.000000	0.000000
50%	2500.500000	45.000000	20.000000	64.000000	93437.000000	2.000000	1.500000	2.000000	0.000000	0.000000	0.00000	1.000000	0.000000	0.000000
75%	3750.250000	55.000000	30.000000	98.000000	94608.000000	3.000000	2.500000	3.000000	101.000000	0.000000	0.00000	1.000000	1.000000	0.000000
max	5000.000000	67.000000	43.000000	224.000000	96651.000000	4.000000	10.000000	3.000000	635.000000	1.000000	1.00000	1.000000	1.000000	1.000000

Supervised Learning Project¶

PART 1 ¶

1.Data Understanding:¶

Import Libraries¶

Data Preparation and Exploration:¶

3. Data Analysis:¶

Univariate analysis¶

Bivariate Analysis¶

Multivariate Analysis¶

Data pre-processing:¶

Perform normalisation or scaling.¶

Model Building:¶

Computing the confusion Matrix¶

THE FINAL BEST MODEL USING K=5¶

Performance Improvement.¶

6. Conclusion and improvisation:¶

Conclusion:¶

The final model uses k=5 for prediction and has a good accuracy as well as recall score¶

Model Accuracy : 84 %¶

Model Macro Average Recall Score : 82 %¶

PART 2 ¶

Univariate analysis:¶

Bivariate Analysis¶

Multivariate Analysis¶

Data Preparation and model building:¶

Balancing the Target Variable 'LoanOnCard' using SMOTE(Synthetic Minority Over-sampling Technique)¶

• Perform train-test split.¶

Model training, testing and tuning:¶

• Design and train a Logistic regression and Naive Bayes classifiers.¶

Train and test the model using Logistic Regression algorithm.¶

Standardize features by removing the mean and scaling to unit variance.¶

• Apply all the possible tuning techniques to train the best model for the given data. Select the final best trained model with your comments for selecting this model.¶

Handling Data leakage by using SMOTE on only training data¶

Split the data as train and test¶

Perform oversampling using SMOTE only on training dataset to avoid data leakage¶

Build a final Model using training and test data.¶

The model is 88% accurate on both train and test data.¶

The Final Confusion Matrix¶

The Final Classification Report¶

Conclusion and improvisation:¶

Conclusion:¶

Final Model uses : Logistic Regression¶

Model Accuracy : 88 %¶

Improvisation:¶

Suggestions for Expanding the Business:¶